export interface TreeNode {
    id: number | string,
    name: string,
    children?: TreeNode[],
}

/**
 * 获取树中某个节点的所有叶子节点ID
 * @param tree 树形结构数据
 * @param targetId 目标节点ID
 * @returns 叶子节点ID数组
 */
export function getLeafIds<T extends TreeNode>(tree: T[], targetId: number | string): (number | string)[] {
    const leafIds: (string | number)[] = [];

    // 内部递归函数
    function traverse(node: T): boolean {
        if (node.id === targetId) {
            // 找到目标节点，收集其下所有叶子节点
            collectLeafIds(node);
            return true;
        }

        if (node.children && node.children.length > 0) {
            for (const child of node.children as T[]) {
                if (traverse(child)) {
                    return true;
                }
            }
        }
        return false;
    }

    // 收集叶子节点ID的函数
    function collectLeafIds(node: T): void {
        if (!node.children || node.children.length === 0) {
            // 当前节点是叶子节点
            leafIds.push(node.id);
        } else {
            // 递归处理子节点
            for (const child of node.children as T[]) {
                collectLeafIds(child);
            }
        }
    }

    // 处理传入的是数组或单个节点的情况
    if (Array.isArray(tree)) {
        for (const node of tree) {
            if (traverse(node)) {
                break;
            }
        }
    } else {
        traverse(tree);
    }

    return leafIds;
}

export function transformElTree(data: TreeNode[]) {
    // 如果传入的不是数组，直接返回空数组（或者根据你的需求处理）
    if (!Array.isArray(data)) {
        return [];
    }

    return data.map(item => {
        // 创建一个新对象，只包含你需要的字段
        const newItem = {
            value: item.id,
            label: item.name,
            children: []
        };

        // 如果原始 item 有 children，递归处理
        if (item.children && item.children.length > 0) {
            newItem.children = transformElTree(item.children);
        }

        return newItem;
    });
}